import { ElMessage, ElNotification } from 'element-plus'
import { dateFormatter1 } from '@/assets/js/main.js'

// 八字排盘API接口
import {
  startsApi, // 开始排盘
  daYunLiuNianInitializeApi, // 初始化大运流年
  daYunApi, // 大运切换
  liuNianApi, // 流年\小运切换
  liuYueApi, // 流月切换
  ganZhiTuJieApi, // 干支图解
  getNowGanZhiApi, // 获取当前日期的干支
  ganZhiToDateApi, // 通过干支获取日期
  isLeapMonthApi // 判断日期是否为闰月
} from '@/api/gongju/bazipaipan-api.js'

export default {
  el: 'app',
  data() {
    return {
      /* 一、顶部左侧导航 */

      topLeftNavigations: [
        {
          id: 1,
          title: '首页', // 名称
          link: '/', // 路由
          icon: 'ios-home' // 图标
        },
        {
          id: 2,
          title: '辅助工具',
          link: '',
          icon: 'md-color-wand'
        },
        {
          id: 3,
          title: '八字排盘',
          link: '',
          icon: 'md-pin'
        }
      ],

      //*****************************************************************************

      /* 二、顶部右侧导航 */

      topRightNavigations: [
        {
          id: 1,
          title: '奇门排盘', // 名称
          link: '/gongju/qimendunjia', // 路由
          icon: 'ios-open-outline' // 图标
        },
        {
          id: 2,
          title: '六爻起卦',
          link: '/gongju/liuyao',
          icon: 'ios-open-outline'
        },
        {
          id: 3,
          title: '梅花易数起卦',
          link: '/gongju/meihuayishu',
          icon: 'ios-open-outline'
        },
        {
          id: 4,
          title: '紫微斗数排盘',
          link: '/gongju/PaiPan',
          icon: 'ios-open-outline'
        }
      ],
      mark: 'bzpp', // 二级导航标识

      //*****************************************************************************

      /* 三、页面显示控制 */

      dataPage: 1, // 数据默认显示页面（1:示例数据+选项。2:完整信息）
      dataWanZhengPage: 1, // 完整数据默认显示页面（1:基础信息。2:命盘信息。3:其他信息）

      //*****************************************************************************

      /* 四、示例数据 */

      dataShiLi: {}, // 示例数据
      dataShiLiStatus: false, // 示例数据状态（true:存在。false:不存在）

      //*****************************************************************************

      /* 五、完整数据 */

      dataWanZheng: {}, // 完整数据
      dataWanZhengBackups: {}, // 完整数据备份
      dataWanZhengStatus: false, // 完整数据状态（true:存在。false:不存在）

      ganZhiYinYang: false, // 干支阴阳（true:阴干支显示斜体。false:阴干支不显示斜体）
      cangGanWuXingSwitch: false, // 是否显示包含藏干的五行个数（true:显示。false:不显示）
      caiHuaTab: '1', // 默认显示正财年
      otherTab: '1', // 默认显示太岁

      //----------------------------------------------------------------------------

      // 命盘数据

      mingPanMode: 2, // 命盘显示模式（1:四柱。2:四柱+大运、流年。3:四柱+大运、流年、流月）
      mingPanModeStr: '默认', // 命盘显示模式（默认为：四柱+大运、流年等）
      mingPanModeOptions: ['四柱', '默认'],
      isMinPanToDaYunLiuNian: false, // 记录命盘数据是否是从大运流年处切换（true:是。false:否）

      daYunLiuNianData: {}, // 大运流年数据
      daYunLiuNianDataStatus: false, // 大运流年数据状态（true:存在。false:不存在）

      daYunData: [], // 大运数据
      liuNianData: [], // 流年数据
      xiaoYunData: [], // 小运数据
      liuYueData: [], // 流月数据

      daYunDataFirst: [], // 第一轮大运数据
      liuNianDataFirst: [], // 第一轮流年数据
      xiaoYunDataFirst: [], // 第一轮小运数据
      liuYueDataFirst: [], // 第一轮流月数据

      daYunMingPanData: [], // 大运命盘数据
      liuNianMingPanData: [], // 流年命盘数据
      xiaoYunMingPanData: [], // 小运命盘数据
      liuYueMingPanData: [], // 流月命盘数据

      daYunMingPanDataBackups: [], // 大运命盘数据备份
      liuNianMingPanDataBackups: [], // 流年命盘数据备份

      daYunLun: 1, // 大运轮
      liuNianXiaoYunLun: 1, // 流年\小运轮
      liuYueLun: 0, // 流月轮

      tianGanLiuYi: {}, // 天干留意
      diZhiLiuYi: {}, // 地支留意

      daYunGanZhi: '', // 大运干支
      liuNianGanZhi: '', // 流年干支
      xiaoYunGanZhi: '', // 小运干支
      liuYueGanZhi: '', // 流月干支

      solarYear: 0, // 公历年
      solarMonth: 0, // 公历月
      solarDay: 0, // 公历日

      //----------------------------------------------------------------------------

      // 干支关系

      yunNianTianGanLiuYi: [], // 天干留意（四柱+大运、流年）
      yunNianDiZhiLiuYi: [], // 地支留意（四柱+大运、流年）

      yunNianYueTianGanLiuYi: [], // 天干留意（四柱+大运、流年、流月）
      yunNianYueDiZhiLiuYi: [], // 地支留意（四柱+大运、流年、流月）

      //----------------------------------------------------------------------------

      // 干支图解

      ganZhiTuJieModal: false,  // 干支图解弹窗（true:显示。false:隐藏）
      ganZhiTuJieMode: 1, // 干支图解模式（1:四柱。2:四柱+大运、流年。3:四柱+大运、流年、流月）

      tianGanTuJie: [], // 天干图解
      dizZhiTuJie: [], // 地支图解

      //*****************************************************************************

      /* 六、主要选项 */

      name: '', // 姓名
      occupy: '', // 占事
      sex: 1, // 性别
      sexStr: '男', // 性别
      sexOptions: ['男', '女'],
      date: '', // 日期
      dateType: 0, // 日期类型
      dateTypeStr: '公历', // 日期类型
      dateTypeOptions: ['公历', '农历', '四柱'],
      isLeapMonth: false, // 是否闰月（true:是。false:否）
      isLeapMonthStatus: false, // 是否闰月状态（true:可选。false:不可选）
      isTrueSolar: false, // 是否真太阳时（true:是。false:否）
      address: '110000', // 地区：城市编码
      addressName: '北京市', // 地区：城市名称
      qiYunLiuPai: 0, // 起运流派
      qiYunLiuPaiOptions: [
        { value: 0, label: '按天和时辰计算' },
        { value: 1, label: '按分钟计算' }
      ],
      isResettingDate: false, // 是否重置日期（true:是。false:否）
      startsButton: true, // 开始排盘按钮状态（true:启用。false:禁用）

      //*****************************************************************************

      /* 七、更多选项弹窗 */

      moreOptionsModal: false,  // 更多选项弹窗（true:显示。false:隐藏）

      yearGanZhiSet: 1, // 年干支设置
      yearGanZhiSetOptions: [
        { value: 0, label: '以正月初一作为新年的开始' },
        { value: 1, label: '以立春作为新年的开始' },
        { value: 2, label: '以立春交接的时刻作为新年的开始' }
      ],
      monthGanZhiSet: 1, // 月干支设置
      monthGanZhiSetOptions: [
        { value: 0, label: '以节交接当天起算' },
        { value: 1, label: '以节交接时刻起算' }
      ],
      dayGanZhiSet: 0, // 日干支设置
      dayGanZhiSetOptions: [
        { value: 0, label: '晚子时日干支算当天' },
        { value: 1, label: '晚子时日干支算明天' }
      ],
      hourGanZhiSet: 0, // 时干支设置
      hourGanZhiSetOptions: [
        { value: 0, label: '支持早子时和晚子时' }
      ],

      renYuanType: 0, // 人元司令分野类型
      renYuanTypeOptions: [
        { value: 0, label: '子平真诠法决' },
        { value: 1, label: '渊海子平法决' },
        { value: 2, label: '星平会海法决' },
        { value: 3, label: '三命通会法决' },
        { value: 4, label: '神峰通考法决' },
        { value: 5, label: '万育吾之法决' }
      ],

      ganZhiYinYang: false, // 干支阴阳（true:阴干支显示斜体。false:阴干支不显示斜体）
      cangGanWuXingSwitch: false, // 是否显示包含藏干的五行个数（true:显示。false:不显示）

      muColor: '#00ad00', // 五行木颜色
      huoColor: '#d40000', // 五行火颜色
      tuColor: '#b16400', // 五行土颜色
      jinColor: '#efa800', // 五行金颜色
      shuiColor: '#2e83f6', // 五行水颜色

      //*****************************************************************************

      /* 四柱转日期弹窗 */

      siZhuToDateModal: false,  // 四柱转日期弹窗（true:显示。false:隐藏）

      // 日期表格标题
      siZhuToDateColumns: [
        { type: 'index', title: '序号', width: 60, align: 'center', resizable: true },
        { title: '公历日期', key: 'solar', width: 150, align: 'center', resizable: true },
        { title: '农历日期', key: 'lunar', width: 200, align: 'center', resizable: true },
        { title: '操作', slot: 'action', align: 'center', resizable: true }
      ],
      siZhuToDate: [], // 日期
      siZhuToDateTotal: 0, // 日期条数
      beginYear: 1900, // 起始年
      yearGanZhi: '', // 年干支
      monthGanZhi: '', // 月干支
      dayGanZhi: '', // 日干支
      hourGanZhi: '', // 时干支
      ganZhiOptions: [ // 六十甲子
        { value: '甲子', label: '甲子' },
        { value: '甲戌', label: '甲戌' },
        { value: '甲申', label: '甲申' },
        { value: '甲午', label: '甲午' },
        { value: '甲辰', label: '甲辰' },
        { value: '甲寅', label: '甲寅' },
        { value: '乙丑', label: '乙丑' },
        { value: '乙亥', label: '乙亥' },
        { value: '乙酉', label: '乙酉' },
        { value: '乙未', label: '乙未' },
        { value: '乙巳', label: '乙巳' },
        { value: '乙卯', label: '乙卯' },
        { value: '丙寅', label: '丙寅' },
        { value: '丙子', label: '丙子' },
        { value: '丙戌', label: '丙戌' },
        { value: '丙申', label: '丙申' },
        { value: '丙午', label: '丙午' },
        { value: '丙辰', label: '丙辰' },
        { value: '丁卯', label: '丁卯' },
        { value: '丁丑', label: '丁丑' },
        { value: '丁亥', label: '丁亥' },
        { value: '丁酉', label: '丁酉' },
        { value: '丁未', label: '丁未' },
        { value: '丁巳', label: '丁巳' },
        { value: '戊辰', label: '戊辰' },
        { value: '戊寅', label: '戊寅' },
        { value: '戊子', label: '戊子' },
        { value: '戊戌', label: '戊戌' },
        { value: '戊申', label: '戊申' },
        { value: '戊午', label: '戊午' },
        { value: '己巳', label: '己巳' },
        { value: '己卯', label: '己卯' },
        { value: '己丑', label: '己丑' },
        { value: '己亥', label: '己亥' },
        { value: '己酉', label: '己酉' },
        { value: '己未', label: '己未' },
        { value: '庚午', label: '庚午' },
        { value: '庚辰', label: '庚辰' },
        { value: '庚寅', label: '庚寅' },
        { value: '庚子', label: '庚子' },
        { value: '庚戌', label: '庚戌' },
        { value: '庚申', label: '庚申' },
        { value: '辛未', label: '辛未' },
        { value: '辛巳', label: '辛巳' },
        { value: '辛卯', label: '辛卯' },
        { value: '辛丑', label: '辛丑' },
        { value: '辛亥', label: '辛亥' },
        { value: '辛酉', label: '辛酉' },
        { value: '壬申', label: '壬申' },
        { value: '壬午', label: '壬午' },
        { value: '壬辰', label: '壬辰' },
        { value: '壬寅', label: '壬寅' },
        { value: '壬子', label: '壬子' },
        { value: '壬戌', label: '壬戌' },
        { value: '癸酉', label: '癸酉' },
        { value: '癸未', label: '癸未' },
        { value: '癸巳', label: '癸巳' },
        { value: '癸卯', label: '癸卯' },
        { value: '癸丑', label: '癸丑' },
        { value: '癸亥', label: '癸亥' }
      ],
      siZhuToDateButtonStatus: true, // 四柱转日期按钮状态（true:启用。false:禁用）

      yearGanZhiBackups: '', // 年干支备份
      monthGanZhiBackups: '', // 月干支备份
      dayGanZhiBackups: '', // 日干支备份
      hourGanZhiBackups: '', // 时干支备份

      //*****************************************************************************

      /* 人元司令分野参考弹窗 */

      renYuanCanKaoModal: false,  // 人元司令分野参考弹窗（true:显示。false:隐藏）

      //*****************************************************************************

      /* 干支参考页面 */

      ganZhiCanKao: 1, // 干支参考默认显示页面（1:天干关系参考。2:地支关系参考。3:神煞查法参考）

      tianGanCanKao: '1', // 天干参考默认显示的数据
      diZhiCanKao: '1', // 地支参考默认显示的数据
      shenShaCanKao: '1', // 神煞参考默认显示的数据


      resettingButtonStatus: true, // 记录是否已点击重置按钮（true:已点击。false:未点击）
      screenWidth: null,
      dialog: 500
    }
  },
  watch: {
    // 姓名监听
    name(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 占事监听
    occupy(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 性别监听
    sexStr(val) {
      if (val === '男') {
        this.sex = 1;
        // this.getShiLiDataMethod(); // 获取示例数据
      } else if (val === '女') {
        this.sex = 0;
        // this.getShiLiDataMethod(); // 获取示例数据
      }
    },
    // 日期监听
    date(val) {
      if (this.dateTypeStr === '农历') {
        this.isLeapMonthMethod(this.date); // 判断日期是否为闰月
      }
      // if (this.resettingButtonStatus) this.getShiLiDataMethod(); // 获取示例数据
    },
    // 日期类型监听
    dateTypeStr(val) {
      if (val === '公历') {
        this.dateType = 0; // 日期类型转为公历
        this.isLeapMonth = false; // 取消闰月
        this.isLeapMonthStatus = false; // 禁用闰月选项
        // if (this.resettingButtonStatus) this.getShiLiDataMethod(); // 获取示例数据
      } else if (val === '农历') {
        this.dateType = 1; // 日期类型转为农历
        if (this.resettingButtonStatus) this.isLeapMonthMethod(this.date); // 判断日期是否为闰月
        // if (this.resettingButtonStatus) this.getShiLiDataMethod(); // 获取示例数据
      } else if (val === '四柱') {
        this.isLeapMonth = false; // 取消闰月
        this.isLeapMonthStatus = false; // 禁用闰月选项
        this.getNowGanZhiMethod(); // 获取当前日期干支
      }
    },
    // 是否真太阳时选项监听
    isTrueSolar(val) {
      if (!val) {
        this.address = '110000' // 重置城市编码
        this.addressName = '北京市' // 重置城市名称
      }
    },
    // 是否闰月监听
    isLeapMonth(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 地区监听
    addressName(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 起运流派监听
    qiYunLiuPai(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 年干支设置监听
    yearGanZhiSet(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 月干支设置监听
    monthGanZhiSet(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 日干支设置监听
    dayGanZhiSet(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 时干支设置监听
    hourGanZhiSet(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 人元司令分野类型监听
    renYuanType(val) {
      // this.getShiLiDataMethod(); // 获取示例数据
    },
    // 大运轮数监听
    daYunLunSet(val) {

    },
    // 起始年监听
    beginYear(val) {

    },
    // 四柱转日期弹窗监听
    siZhuToDateModal(val) {
      if (!val) {
        // 若四柱转日期弹窗未显示，则将日期类型转为公历
        this.dateType = 0;
        this.dateTypeStr = '公历';
      } else {
        this.siZhuToDateTotal = 0; // 重置四柱转日期条数
      }
    },

    // 是否显示包含藏干的五行个数监听
    cangGanWuXingSwitch(val) {
      if (val) {
        this.dataWanZheng.muCount = this.dataWanZheng.muZhiCount; // 五行木数量（包含地支藏干五行）
        this.dataWanZheng.huoCount = this.dataWanZheng.huoZhiCount; // 五行火数量（包含地支藏干五行）
        this.dataWanZheng.tuCount = this.dataWanZheng.tuZhiCount; // 五行土数量（包含地支藏干五行）
        this.dataWanZheng.jinCount = this.dataWanZheng.jinZhiCount; // 五行金数量（包含地支藏干五行）
        this.dataWanZheng.shuiCount = this.dataWanZheng.shuiZhiCount; // 五行水数量（包含地支藏干五行）
      } else {
        this.dataWanZheng.muCount = this.dataWanZhengBackups.muCount; // 五行木数量（不包含地支藏干五行）
        this.dataWanZheng.huoCount = this.dataWanZhengBackups.huoCount; // 五行火数量（不包含地支藏干五行）
        this.dataWanZheng.tuCount = this.dataWanZhengBackups.tuCount; // 五行土数量（不包含地支藏干五行）
        this.dataWanZheng.jinCount = this.dataWanZhengBackups.jinCount; // 五行金数量（不包含地支藏干五行）
        this.dataWanZheng.shuiCount = this.dataWanZhengBackups.shuiCount; // 五行水数量（不包含地支藏干五行）
      }
    },

    // 命盘模式监听
    mingPanModeStr(val) {
      if (val === '四柱') {
        this.mingPanMode = 1; // 更改命盘显示模式（四柱）
        this.daYunLun = 1; // 初始化大运轮数
        this.liuNianXiaoYunLun = 1; // 初始化流年\小运轮数
        this.liuYueLun = 0; // 初始化流月轮数
        this.liuRiLun = 0; // 初始化流日轮数
        this.liuShiLun = 0; // 初始化流时轮数
        this.liuRiDataStatus = false; // 隐藏流日数据
        this.liuShiDataStatus = false; // 隐藏流时数据
        this.liuNianData = this.liuNianDataFirst; // 重新设置流年数据为第一轮
        this.xiaoYunData = this.xiaoYunDataFirst; // 重新设置小运数据为第一轮
      } else if (val === '默认') {
        this.mingPanMode = 2; // 更改命盘显示模式（四柱+大运、流年）
        this.daYunMingPanData = this.daYunMingPanDataBackups; // 重新设置大运命盘数据
        this.liuNianMingPanData = this.liuNianMingPanDataBackups; // 重新设置流年命盘数据
      }
    },
    // 五行木颜色监听
    muColor(val) {
      if ('' == val) this.muColor = '#00ad00';
      if ('#FFFFFF' == val) this.muColor = '#00ad00';
    },
    // 五行火颜色监听
    huoColor(val) {
      if ('' == val) this.huoColor = '#d40000';
      if ('#FFFFFF' == val) this.huoColor = '#d40000';
    },
    // 五行土颜色监听
    tuColor(val) {
      if ('' == val) this.tuColor = '#b16400';
      if ('#FFFFFF' == val) this.tuColor = '#b16400';
    },
    // 五行金颜色监听
    jinColor(val) {
      if ('' == val) this.jinColor = '#efa800';
      if ('#FFFFFF' == val) this.jinColor = '#efa800';
    },
    // 五行水颜色监听
    shuiColor(val) {
      if ('' == val) this.shuiColor = '#2e83f6';
      if ('#FFFFFF' == val) this.shuiColor = '#2e83f6';
    }
  },
  created() {
    this.date = new Date(); // 初始化日期
    this.getShiLiDataMethod(); // 获取示例数据
    this.updateScreenWidth()
    window.addEventListener('resize', this.updateScreenWidth)
  },
  mounted() {
  },
  methods: {
    updateScreenWidth(){
      this.screenWidth = window.innerWidth
      if (this.screenWidth < 600) {
        this.dialog = '88%' || '500'
      } else {
        this.dialog = '500'
      }
      // dialog.value = screenWidth.value
    },

    /* 示例数据 */

    /**
     * 获取示例数据
     */
    getShiLiDataMethod() {

      // 请求参数
      let query = {
        name: this.name == '' ? '缘主' : this.name, // 姓名
        occupy: this.occupy, // 占事
        sex: this.sex, // 性别
        date: this.date, // 日期
        dateType: this.dateType, // 日期类型
        // address: this.addressName, // 地区名称
        isLeapMonth: this.isLeapMonth, // 是否闰月
        qiYunLiuPai: this.qiYunLiuPai, // 起运流派
        yearGanZhiSet: this.yearGanZhiSet, // 年干支设置
        monthGanZhiSet: this.monthGanZhiSet, // 月干支设置
        dayGanZhiSet: this.dayGanZhiSet, // 日干支设置
        hourGanZhiSet: this.hourGanZhiSet, // 时干支设置
        renYuanType: this.renYuanType, // 人元司令分野类型
        isShiLi: true // 是否为示例数据
      }

      // 发送请求
      startsApi(query).then((res) => {
        if (String(res.data.code) === '200') {
          let data = res.data.data;
          if (null !== data) {
            this.dataShiLi = data;
            this.dataShiLiStatus = true; // 将示例数据状态设置为存在
            this.dataPage = 1; // 数据默认显示页面（1:示例数据+选项。2、完整信息）
          }
        } else {
          this.notification('error', 1500, '', res.data.msg || '操作失败');
        }
      })

    },

    //****************************************************************************************

    /* 完整数据 */

    /**
     * 获取完整数据
     */
    getWanZhengDataMethod() {

      this.startsButton = false; // 禁用开始排盘按钮

      setTimeout(() => {
        // 条件构造
        let query = {
          name: this.name == '' ? '缘主' : this.name, // 姓名
          occupy: this.occupy, // 占事
          sex: this.sex, // 性别
          date: this.date, // 日期
          dateType: this.dateType, // 日期类型
          address: this.addressName, // 地区名称
          isLeapMonth: this.isLeapMonth, // 是否闰月
          qiYunLiuPai: this.qiYunLiuPai, // 起运流派
          yearGanZhiSet: this.yearGanZhiSet, // 年干支设置
          monthGanZhiSet: this.monthGanZhiSet, // 月干支设置
          dayGanZhiSet: this.dayGanZhiSet, // 日干支设置
          hourGanZhiSet: this.hourGanZhiSet, // 时干支设置
        }

        // 发送请求
        startsApi(query).then((res) => {
          if (String(res.data.code) === '200') {
            let data = res.data.data;
            if (null !== data) {
              this.dataWanZheng = data;

              this.startsButton = true; // 启用开始排盘按钮
              this.dataWanZhengStatus = true; // 将完整数据状态设置为存在
              this.dataPage = 2; // 数据默认显示页面（1:示例数据+选项。2、完整信息）

              this.dataWanZhengBackupsMethod(this.dataWanZheng); // 完整数据备份

              // this.elMessage(3000, true, 'success', res.data.msg || '操作成功');
            } else {
              this.startsButton = true; // 启用开始排盘按钮
              this.notification('warning', 1500, '', '数据不存在');
            }
          } else {
            this.startsButton = true; // 启用开始排盘按钮
            this.notification('error', 1500, '', res.data.msg || '操作失败');
          }
        }).catch(() => {
          this.startsButton = true; // 启用开始排盘按钮
          // this.notification('error', 1500, '', '操作失败');
        })
      }, 0);

    },

    /**
     * 完整数据备份
     * 
     * @param {} data 完整数据
     */
    dataWanZhengBackupsMethod(data) {

      this.dataWanZhengBackups = {
        muCount: data.muCount, // 五行木数量（不包含地支藏干五行）
        huoCount: data.huoCount, // 五行火数量（不包含地支藏干五行）
        tuCount: data.tuCount, // 五行土数量（不包含地支藏干五行）
        jinCount: data.jinCount, // 五行金数量（不包含地支藏干五行）
        shuiCount: data.shuiCount, // 五行水数量（不包含地支藏干五行）
      }

    },

    /**
     * 初始化大运流年
     */
    initializeDaYunLiuNian() {

      // 判断是否已初始化大运流年
      if (this.daYunLiuNianDataStatus) return;

      // 条件构造
      let query = {
        yearGan: this.dataWanZheng.yearGan,   // 年干
        monthGan: this.dataWanZheng.monthGan, // 月干
        dayGan: this.dataWanZheng.dayGan,     // 日干
        hourGan: this.dataWanZheng.hourGan,   // 时干

        yearZhi: this.dataWanZheng.yearZhi,   // 年支
        monthZhi: this.dataWanZheng.monthZhi, // 月支
        dayZhi: this.dataWanZheng.dayZhi,     // 日支
        hourZhi: this.dataWanZheng.hourZhi,   // 时支

        date: this.dataWanZheng.date, // 日期
        season: this.dataWanZheng.season, // 季节
        yearGanZhiNaYinWuXing: this.dataWanZheng.yearGanZhiNaYin.substring(2, 3), // 年干支纳音五行
        sex: this.dataWanZheng.sex == '女' ? 0 : 1, // 性别
        qiYunLiuPai: this.qiYunLiuPai, // 起运流派
        daYunLunSet: this.daYunLunSet // 大运轮数设置
      }

      // 发送请求
      daYunLiuNianInitializeApi(query).then((res) => {
        if (String(res.data.code) === '200') {
          let data = res.data.data;
          if (null !== data) {

            // this.daYunLiuNianData = data; // 用于命盘数据展示（因后台返回数据格式问题，若直接设置会导致界面其他部分数据消失）

            this.daYunMingPanData = data; // 大运命盘数据
            this.liuNianMingPanData = data; // 流年命盘数据
            this.daYunMingPanDataBackups = data; // 大运命盘数据备份
            this.liuNianMingPanDataBackups = data; // 流年命盘数据备份

            this.daYunData = data.daYun; // 大运数据
            this.liuNianData = data.liuNian; // 流年数据
            this.xiaoYunData = data.xiaoYun; // 小运数据
            this.liuYueData = data.liuYue; // 流月数据

            this.daYunDataFirst = data.daYun; // 第一轮大运数据
            this.liuNianDataFirst = data.liuNian; // 第一轮流年数据
            this.xiaoYunDataFirst = data.xiaoYun; // 第一轮小运数据
            this.liuYueDataFirst = data.liuYue; // 第一轮流月数据

            this.yunNianTianGanLiuYi = data.tianGanLiuYi; // 天干留意（四柱+大运、流年）
            this.yunNianDiZhiLiuYi = data.diZhiLiuYi; // 地支留意（四柱+大运、流年）

            // 设置公历年、公历月
            if (data.liuNian.length == 0) {
              this.solarYear = parseInt(data.daYun[0][0]); // 公历年。若流年数据个数为0，则取第一轮大运的第一年
            } else {
              this.solarYear = parseInt(data.liuNian[0][0]); // 公历年。若流年数据个数不为0，则取第一轮流年的第一年
            }
            this.solarMonth = parseInt(data.liuYue[0][0]); // 公历月

            // 设置大运干支、流年干支
            if (data.xiaoYun.length == 0) {
              this.daYunGanZhi = data.daYunData[1][2]; // 大运干支。若小运数据个数为0，直接取第一轮的第一个大运干支
            } else {
              this.daYunGanZhi = data.xiaoYun[0][2]; // 大运干支。将大运干支替换为第一轮的第一个小运干支
            }
            this.liuNianGanZhi = data.liuNian[this.liuNianXiaoYunLun - 1][2]; // 流年干支

            this.daYunLiuNianDataStatus = true; // 大运流年数据状态（true:存在。false:不存在）
            this.dataWanZhengPage = 2; // 将完整数据显示页面切换为命盘信息

            // this.elMessage(3000, true, 'success', res.data.msg || '操作成功');
          } else {
            this.daYunLiuNianDataStatus = false; // 大运流年数据状态（true:存在。false:不存在）
            this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
          }
        } else {
          this.daYunLiuNianDataStatus = false; // 大运流年数据状态（true:存在。false:不存在）
          this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
        }
      }).catch(() => {
        this.daYunLiuNianDataStatus = false; // 大运流年数据状态（true:存在。false:不存在）
        // this.elMessage(3000, true, 'error', '数据加载失败，请稍后重试 ~');
      })

    },

    /**
     * 大运切换
     * 
     * @param {number} daYunLun    大运轮
     * @param {number} daYunGanZhi 大运干支
     */
    daYunQieHuanMethod(daYunLun, daYunGanZhi) {

      this.daYunLun = daYunLun; // 设置大运轮

      this.liuRiDataStatus = false; // 隐藏流日数据
      this.liuShiDataStatus = false; // 隐藏流时数据

      this.liuYueLun = 0; // 重置流月轮
      this.liuRiLun = 0; // 重置流日轮
      this.liuShiLun = 0; // 重置流时轮

      this.liuRiData = []; // 清空流日数据
      this.liuShiData = []; // 清空流时数据

      // 设置大运干支
      if (daYunLun === 1) {
        this.liuNianXiaoYunLun = 1; // 流年\小运轮数重置为第一轮
        if (this.xiaoYunData.length == 0) {
          this.daYunGanZhi = this.daYunData[1][2]; // 大运干支。若小运数据个数为0，直接取第一轮的第一个大运干支
        } else {
          this.daYunGanZhi = this.xiaoYunDataFirst[0][2]; // 大运干支。将大运干支替换为第一轮的第一个小运干支
        }
      } else {
        this.daYunGanZhi = daYunGanZhi; // 大运干支
      }

      // 条件构造
      let query = {
        yearGan: this.dataWanZheng.yearGan,   // 年干
        monthGan: this.dataWanZheng.monthGan, // 月干
        dayGan: this.dataWanZheng.dayGan,     // 日干
        hourGan: this.dataWanZheng.hourGan,   // 时干
        daYunGan: this.daYunGanZhi.substring(0, 1), // 大运干

        yearZhi: this.dataWanZheng.yearZhi,   // 年支
        monthZhi: this.dataWanZheng.monthZhi, // 月支
        dayZhi: this.dataWanZheng.dayZhi,     // 日支
        hourZhi: this.dataWanZheng.hourZhi,   // 时支
        daYunZhi: this.daYunGanZhi.substring(1, 2), // 大运支

        daYunLun: daYunLun, // 大运轮
        liuNianLun: this.liuNianXiaoYunLun, // 流年\小运轮

        date: this.dataWanZheng.date, // 日期
        season: this.dataWanZheng.season, // 季节
        yearGanZhiNaYinWuXing: this.dataWanZheng.yearGanZhiNaYin.substring(2, 3), // 年干支纳音五行
        sex: this.dataWanZheng.sex == '女' ? 0 : 1, // 性别
        qiYunLiuPai: this.qiYunLiuPai // 起运流派
      }

      // 发送请求
      daYunApi(query).then((res) => {
        if (String(res.data.code) === '200') {
          let data = res.data.data;
          if (null !== data) {

            // this.daYunLiuNianData = data; // 用于命盘数据展示（因后台返回数据格式问题，若直接设置会导致界面其他部分数据消失）

            this.daYunMingPanData = data; // 大运命盘数据
            this.liuNianMingPanData = data; // 流年命盘数据
            this.liuYueMingPanData = data; // 流月命盘数据

            this.liuNianData = data.liuNian; // 流年数据
            this.xiaoYunData = data.xiaoYun; // 小运数据
            this.liuYueData = data.liuYue; // 流月数据

            this.yunNianTianGanLiuYi = data.tianGanLiuYi; // 天干留意（四柱+大运、流年）
            this.yunNianDiZhiLiuYi = data.diZhiLiuYi; // 地支留意（四柱+大运、流年）

            this.isMinPanToDaYunLiuNian = true; // 记录命盘数据是否是从大运流年处切换（true:是。false:否）
            this.mingPanMode = 2; // 更改命盘显示模式（四柱+大运、流年）
            this.mingPanModeStr = "默认"; // 切换命盘显示模式选项

            // 若大运轮数为1，则重置流年干支、公历年
            if (daYunLun === 1) {
              this.liuNianGanZhi = data.liuNianGanZhi; // 重置流年干支
              this.solarYear = parseInt(this.daYunDataFirst[0][0]); // 重置公历年
            }

            // this.elMessage(3000, true, 'success', res.data.msg || '操作成功');
          } else {
            this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
          }
        } else {
          this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
        }
      }).catch(() => {
        // this.elMessage(3000, true, 'error', '数据加载失败，请稍后重试 ~');
      })

    },

    /**
     * 流年\小运切换
     * 
     * @param {number} liuNianXiaoYunLun 流年\小运轮
     * @param {number} solarYear         公历年
     * @param {number} liuNianGanZhi     流年干支
     */
    liuNianXiaoYunQieHuanMethod(liuNianXiaoYunLun, solarYear, liuNianGanZhi) {

      this.liuNianXiaoYunLun = liuNianXiaoYunLun; // 设置流年\小运轮
      this.solarYear = parseInt(solarYear); // 设置公历年
      this.liuNianGanZhi = liuNianGanZhi; // 设置流年干支

      this.liuYueLun = 0; // 重置流月轮

      // 条件构造
      let query = {
        yearGan: this.dataWanZheng.yearGan,   // 年干
        monthGan: this.dataWanZheng.monthGan, // 月干
        dayGan: this.dataWanZheng.dayGan,     // 日干
        hourGan: this.dataWanZheng.hourGan,   // 时干
        daYunGan: this.daYunGanZhi.substring(0, 1), // 大运干
        liuNianGan: liuNianGanZhi.substring(0, 1), // 流年干

        yearZhi: this.dataWanZheng.yearZhi,   // 年支
        monthZhi: this.dataWanZheng.monthZhi, // 月支
        dayZhi: this.dataWanZheng.dayZhi,     // 日支
        hourZhi: this.dataWanZheng.hourZhi,   // 时支
        daYunZhi: this.daYunGanZhi.substring(1, 2), // 大运支
        liuNianZhi: this.liuNianGanZhi.substring(1, 2), // 流年支

        daYunLun: this.daYunLun, // 大运轮
        liuNianLun: this.liuNianXiaoYunLun, // 流年\小运轮

        date: this.dataWanZheng.date, // 日期
        season: this.dataWanZheng.season, // 季节
        yearGanZhiNaYinWuXing: this.dataWanZheng.yearGanZhiNaYin.substring(2, 3), // 年干支纳音五行
        sex: this.dataWanZheng.sex == '女' ? 0 : 1, // 性别
        qiYunLiuPai: this.qiYunLiuPai // 起运流派
      }

      // 发送请求
      liuNianApi(query).then((res) => {
        if (String(res.data.code) === '200') {
          let data = res.data.data;
          if (null !== res.data.data) {

            // this.daYunLiuNianData = data; // 用于命盘数据展示（因后台返回数据格式问题，若直接设置会导致界面其他部分数据消失）

            this.liuNianMingPanData = data; // 流年命盘数据

            this.liuYueData = data.liuYue; // 流月数据

            this.yunNianTianGanLiuYi = data.tianGanLiuYi; // 天干留意（四柱+大运、流年）
            this.yunNianDiZhiLiuYi = data.diZhiLiuYi; // 地支留意（四柱+大运、流年）

            this.isMinPanToDaYunLiuNian = true; // 记录命盘数据是否是从大运流年处切换（true:是。false:否）
            this.mingPanMode = 2; // 更改命盘显示模式（四柱+大运、流年）
            this.mingPanModeStr = "默认"; // 切换命盘显示模式选项

            // this.elMessage(3000, true, 'success', res.data.msg || '操作成功');
          } else {
            this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
          }
        } else {
          this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
        }
      }).catch(() => {
        // this.elMessage(3000, true, 'error', '数据加载失败，请稍后重试 ~');
      })

    },

    /**
     * 流月切换
     * 
     * @param {number} liuYueLun    流月轮
     * @param {number} solarMonth   公历月
     * @param {number} liuYueGanZhi 流月干支
     */
    liuYueQieHuanMethod(liuYueLun, solarMonth, liuYueGanZhi) {

      this.liuYueLun = liuYueLun; // 设置流月轮
      this.liuYueGanZhi = liuYueGanZhi; // 设置流月干支
      this.solarMonth = parseInt(solarMonth); // 设置公历月


      // 条件构造
      let query = {
        yearGan: this.dataWanZheng.yearGan,   // 年干
        monthGan: this.dataWanZheng.monthGan, // 月干
        dayGan: this.dataWanZheng.dayGan,     // 日干
        hourGan: this.dataWanZheng.hourGan,   // 时干
        daYunGan: this.daYunGanZhi.substring(0, 1), // 大运干
        liuNianGan: this.liuNianGanZhi.substring(0, 1), // 流年干
        liuYueGan: liuYueGanZhi.substring(0, 1), // 流月干

        yearZhi: this.dataWanZheng.yearZhi,   // 年支
        monthZhi: this.dataWanZheng.monthZhi, // 月支
        dayZhi: this.dataWanZheng.dayZhi,     // 日支
        hourZhi: this.dataWanZheng.hourZhi,   // 时支
        daYunZhi: this.daYunGanZhi.substring(1, 2), // 大运支
        liuNianZhi: this.liuNianGanZhi.substring(1, 2), // 流年支
        liuYueZhi: liuYueGanZhi.substring(1, 2), // 流月支

        solarYear: this.solarYear, // 公历年
        solarMonth: parseInt(solarMonth), // 公历月

        date: this.dataWanZheng.date, // 日期
        season: this.dataWanZheng.season, // 季节
        yearGanZhiNaYinWuXing: this.dataWanZheng.yearGanZhiNaYin.substring(2, 3), // 年干支纳音五行
        sex: this.dataWanZheng.sex == '女' ? 0 : 1, // 性别
        qiYunLiuPai: this.qiYunLiuPai // 起运流派
      }

      // 发送请求
      liuYueApi(query).then((res) => {
        if (String(res.data.code) === '200') {
          let data = res.data.data;
          if (null !== data) {

            // this.daYunLiuNianData = data; // 用于命盘数据展示（因后台返回数据格式问题，若直接设置会导致界面其他部分数据消失）

            this.liuYueMingPanData = data; // 流月命盘数据

            this.yunNianYueTianGanLiuYi = data.tianGanLiuYi; // 天干留意（四柱+大运、流年、流月）
            this.yunNianYueDiZhiLiuYi = data.diZhiLiuYi; // 地支留意（四柱+大运、流年、流月）

            this.isMinPanToDaYunLiuNian = true; // 记录命盘数据是否是从大运流年处切换（true:是。false:否）
            this.mingPanMode = 3; // 更改命盘显示模式（四柱+大运、流年、流月）
            this.mingPanModeStr = "默认"; // 切换命盘显示模式选项

            // this.elMessage(3000, true, 'success', res.data.msg || '操作成功');
          } else {
            this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
          }
        } else {
          this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
        }
      }).catch(() => {
        // this.elMessage(3000, true, 'error', '数据加载失败，请稍后重试 ~');
      })

    },


    /**
     * 干支图解
     * 
     * @param {number} ganZhiTuJieMode 干支图解模式（1:四柱。2:四柱+大运、流年。3:四柱+大运、流年、流月）
     */
    ganZhiTuJieMethod(ganZhiTuJieMode) {

      // 1、处理构造条件
      let query;

      // 1.1、干支图解模式（四柱）
      if (ganZhiTuJieMode == 1) {
        query = {
          ganZhiTuJieMode: 1,

          yearGan: this.dataWanZheng.yearGan, // 年干
          monthGan: this.dataWanZheng.monthGan, // 月干
          dayGan: this.dataWanZheng.dayGan, // 日干
          hourGan: this.dataWanZheng.hourGan, // 时干

          yearZhi: this.dataWanZheng.yearZhi, // 年支
          monthZhi: this.dataWanZheng.monthZhi, // 月支
          dayZhi: this.dataWanZheng.dayZhi, // 日支
          hourZhi: this.dataWanZheng.hourZhi // 时支
        }
      }

      // 1.2、干支图解模式（四柱+大运、流年）
      if (ganZhiTuJieMode == 2) {
        query = {
          ganZhiTuJieMode: 2,

          yearGan: this.dataWanZheng.yearGan,   // 年干
          monthGan: this.dataWanZheng.monthGan, // 月干
          dayGan: this.dataWanZheng.dayGan,     // 日干
          hourGan: this.dataWanZheng.hourGan,   // 时干
          daYunGan: this.daYunGanZhi.substring(0, 1),   // 大运干
          liuNianGan: this.liuNianGanZhi.substring(0, 1), // 流年干

          yearZhi: this.dataWanZheng.yearZhi,   // 年支
          monthZhi: this.dataWanZheng.monthZhi, // 月支
          dayZhi: this.dataWanZheng.dayZhi,     // 日支
          hourZhi: this.dataWanZheng.hourZhi,   // 时支
          daYunZhi: this.daYunGanZhi.substring(1, 2),  // 大运支
          liuNianZhi: this.liuNianGanZhi.substring(1, 2) // 流年支
        }
      }

      // 1.3、干支图解模式（四柱+大运、流年、流月）
      if (ganZhiTuJieMode == 3) {
        query = {
          ganZhiTuJieMode: 3,

          yearGan: this.dataWanZheng.yearGan,   // 年干
          monthGan: this.dataWanZheng.monthGan, // 月干
          dayGan: this.dataWanZheng.dayGan,     // 日干
          hourGan: this.dataWanZheng.hourGan,   // 时干
          daYunGan: this.daYunGanZhi.substring(0, 1),     // 大运干
          liuNianGan: this.liuNianGanZhi.substring(0, 1), // 流年干
          liuYueGan: this.liuYueGanZhi.substring(0, 1),   // 流月干

          yearZhi: this.dataWanZheng.yearZhi,   // 年支
          monthZhi: this.dataWanZheng.monthZhi, // 月支
          dayZhi: this.dataWanZheng.dayZhi,     // 日支
          hourZhi: this.dataWanZheng.hourZhi,   // 时支
          daYunZhi: this.daYunGanZhi.substring(1, 2),     // 大运支
          liuNianZhi: this.liuNianGanZhi.substring(1, 2), // 流年支
          liuYueZhi: this.liuYueGanZhi.substring(1, 2)   // 流月支
        }
      }

      // 2、发送请求
      ganZhiTuJieApi(query).then((res) => {
        if (String(res.data.code) === '200') {
          let data = res.data.data;
          if (null !== data) {

            this.tianGanTuJie = data.tianGanTuJie; // 天干图解
            this.diZhiTuJie = data.diZhiTuJie; // 地支图解

            this.ganZhiTuJieModal = true; // 显示干支图解弹窗
            this.ganZhiTuJieMode = ganZhiTuJieMode; // 设置干支图解模式

            // this.elMessage(3000, true, 'success', res.data.msg || '操作成功');
          } else {
            this.elMessage(3000, true, 'warning', '干支图解加载异常');
          }
        } else {
          this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
        }
      }).catch(() => {
        // this.elMessage(3000, true, 'error', '数据加载失败，请稍后重试 ~');
      })

    },


    //****************************************************************************************

    /* 重置方法  */

    /**
     * 重置全部选项
     */
    resettingAllMethod() {

      this.resettingButtonStatus = false; // 记录是否已点击重置按钮（true:已点击。false:未点击）

      var isFlag = (
        this.name !== '' ||
        this.occupy !== '' ||
        this.sexStr !== '男' ||
        // this.date !== new Date() ||
        this.dateTypeStr !== '公历' ||
        this.isLeapMonth !== false ||
        this.isLeapMonthStatus !== false ||
        this.isTrueSolar !== false ||
        this.address !== '110000' ||
        this.addressName !== '北京市' ||
        this.qiYunLiuPai !== 0 ||
        this.yearGanZhiSet !== 1 ||
        this.monthGanZhiSet !== 1 ||
        this.dayGanZhiSet !== 1 ||
        this.hourGanZhiSet !== 0 ||
        this.mingPanModeStr !== "默认" ||
        this.ganZhiYinYang !== false ||
        this.ganZhiCanKao !== 1
      );

      if (isFlag) {
        this.name = ''; // 姓名
        this.occupy = ''; // 占事
        this.sexStr = '男'; // 性别
        // this.date = new Date(); // 日期
        this.dateTypeStr = '公历'; // 日期类型
        this.isLeapMonth = false; // 是否闰月
        this.isLeapMonthStatus = false; // 是否闰月状态
        this.isTrueSolar = false; // 是否真太阳时
        this.address = '110000'; // 地区：城市编码
        this.addressName = '北京市'; // 地区：城市名称
        this.qiYunLiuPai = 0; // 起运流派
        this.yearGanZhiSet = 1; // 年干支设置
        this.monthGanZhiSet = 1; // 月干支设置
        this.dayGanZhiSet = 1; // 日干支设置
        this.hourGanZhiSet = 0; // 时干支设置
        this.mingPanModeStr = "默认"; // 命盘显示模式选项
        this.ganZhiYinYang = false; // 干支阴阳
        this.ganZhiCanKao = 1; // 干支参考默认显示页面

        this.notification('success', 1000, '', '选项已全部重置');
      } else {
        // this.notification('warning', 1000, '', '选项未更改');
      }

      // 是否重置日期
      if (this.isResettingDate) this.date = new Date();



      this.resettingButtonStatus = true; // 记录是否已点击重置按钮（true:已点击。false:未点击）
      if (isFlag) this.getShiLiDataMethod(); // ★ 获取示例数据

    },

    /**
     * 返回排盘页面
     */
    returnPaiPanPageMethod() {

      this.isResettingDate = false; // 禁止重置日期
      this.resettingAllMethod(); // 重置全部选项

      this.dataPage = 1; // 数据默认显示页面（1:示例数据+选项。2、完整信息）
      this.dataWanZhengPage = 1; // 将完整数据显示页面切换为基本信息

      this.daYunLiuNianDataStatus = false; // 重置大运流年数据状态为不存在

      this.liuRiDataStatus = false; // 隐藏流日数据
      this.liuShiDataStatus = false; // 隐藏流时数据

      this.daYunLun = 1; // 重置大运轮数
      this.liuNianXiaoYunLun = 1; // 重置流年\小运轮数
      this.liuYueLun = 0; // 重置流月轮
      this.liuRiLun = 0; // 重置流日轮
      this.liuShiLun = 0; // 重置流时轮

      this.daYunMingPanDataBackups = []; // 清空大运命盘数据备份
      this.liuNianMingPanDataBackups = []; // 清空流年命盘数据备份

      this.taiMingShenDataStatus = false; // 重置胎命身数据状态为不存在

    },


    //****************************************************************************************

    /* 通用方法  */

    /**
     * 判断日期是否为闰月【用于选项】
     * 
     * @param {Date} date 日期
     */
    isLeapMonthMethod(date) {

      // 条件构造
      let query = {
        date: date, // 日期
      }

      // 发送请求
      isLeapMonthApi(query).then((res) => {
        if (String(res.data.code) === '200') {
          var data = res.data.data;
          if (null !== data) {
            this.isLeapMonthStatus = data; // 否闰月状态（true: 可选。false: 不可选）
          }
        }
      })

    },

    /**
     * 获取当前日期干支【用于四柱转日期弹窗】
     */
    getNowGanZhiMethod() {

      // 请求参数
      let query = {
        date: new Date(), // 日期
        yearGanZhiSet: this.yearGanZhiSet, // 年干支设置
        monthGanZhiSet: this.monthGanZhiSet, // 月干支设置
        dayGanZhiSet: this.dayGanZhiSet, // 日干支设置
        hourGanZhiSet: this.hourGanZhiSet // 时干支设置
      }

      // 发送请求
      getNowGanZhiApi(query).then((res) => {
        if (String(res.data.code) === '200') {
          let data = res.data.data;
          if (null !== data) {
            this.yearGanZhi = data[0]; // 年干支
            this.monthGanZhi = data[1]; // 月干支
            this.dayGanZhi = data[2]; // 日干支
            this.hourGanZhi = data[3]; // 时干支

            this.yearGanZhiBackups = data[0]; // 年干支备份
            this.monthGanZhiBackups = data[1]; // 月干支备份
            this.dayGanZhiBackups = data[2]; // 日干支备份
            this.hourGanZhiBackups = data[3]; // 时干支备份

            this.siZhuToDateModal = true; // 显示四柱转日期弹窗

            // 若四柱转日期弹窗未显示，则将日期类型转为公历
            if (!this.siZhuToDateModal) {
              this.dateType = 0;
              this.dateTypeStr = '公历';
            }
          }
        }
      }).catch(() => {
        this.dateType = 0; // 日期类型转为公历
        this.dateTypeStr = '公历'; // 日期类型转为公历
      })

    },

    /**
     * 通过四柱获取日期【用于四柱转日期弹窗】
     */
    getSiZhuToDateMethod() {

      this.siZhuToDateButtonStatus = false; // 禁用四柱转日期按钮

      this.yearGanZhiBackups2 = this.yearGanZhi; // 年干支备份2
      this.monthGanZhiBackups2 = this.monthGanZhi; // 月干支备份2
      this.dayGanZhiBackups2 = this.dayGanZhi; // 日干支备份2
      this.hourGanZhiBackups2 = this.hourGanZhi; // 时干支备份2

      // 请求参数
      let query = {
        beginYear: this.beginYear, // 起始年份
        yearGanZhi: this.yearGanZhi, // 年干支
        monthGanZhi: this.monthGanZhi, // 月干支
        dayGanZhi: this.dayGanZhi, // 日干支
        hourGanZhi: this.hourGanZhi, // 时干支
        yearGanZhiSet: this.yearGanZhiSet, // 年干支设置
        monthGanZhiSet: this.monthGanZhiSet, // 月干支设置
        dayGanZhiSet: this.dayGanZhiSet, // 日干支设置
        hourGanZhiSet: this.hourGanZhiSet // 时干支设置
      }
      // 发送请求
      ganZhiToDateApi(query).then((res) => {
        if (String(res.data.code) === '200') {
          let data = res.data.data;
          if (null !== data) {
            if (data.length !== 0) {
              this.siZhuToDate = data; // 日期
              this.siZhuToDateTotal = data.length; // 日期条数
              this.siZhuToDateButtonStatus = true; // 启用四柱转日期按钮
            } else {
              this.siZhuToDate = {}; // 清空日期
              this.siZhuToDateTotal = 0; // 清空日期条数
              this.siZhuToDateButtonStatus = true; // 启用四柱转日期按钮
              this.elMessage(3000, true, 'warning', '没有和【' + this.yearGanZhi + ' ' + this.monthGanZhi + ' ' + this.dayGanZhi + ' ' + this.hourGanZhi + '】相匹配的日期');
            }
          } else {
            this.siZhuToDate = {}; // 清空日期
            this.siZhuToDateTotal = 0; // 清空日期条数
            this.siZhuToDateButtonStatus = true; // 启用四柱转日期按钮
            this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
          }
        } else {
          this.siZhuToDate = {}; // 清空日期
          this.siZhuToDateTotal = 0; // 清空日期条数
          this.siZhuToDateButtonStatus = true; // 启用四柱转日期按钮
          this.elMessage(3000, true, 'error', res.data.msg || '操作失败');
        }
      }).catch(() => {
        this.siZhuToDate = {}; // 清空日期
        this.siZhuToDateTotal = 0; // 清空日期条数
        this.siZhuToDateButtonStatus = true; // 启用四柱转日期按钮
        this.elMessage(3000, true, 'error', '请输入有效年份');
      })

    },

    /**
     * 设置新日期【用于四柱转日期弹窗】
     * 
     * @param {string} newDate 公历日期
     */
    setNewDateMethod(newDate) {

      // 处理日期
      this.date = dateFormatter1(newDate);

      this.siZhuToDateModal = false; // 关闭四柱转日期弹窗

      this.elMessage(1500, true, 'success', '日期已设置');

    },

    //****************************************************************************************

    /* 其他方法  */

    /**
     * 切换完整数据显示界面
     * 
     * @param {number} index 完整数据默认显示页面（1:基础信息。2:命盘信息。3:其他信息）
     */
    dataWanZhengPageMethod(index) {

      if (index == 2 && !this.daYunLiuNianDataStatus) {
        try {
          this.initializeDaYunLiuNian(); // 初始化大运流年
        } catch (err) {
          this.notification('error', 3000, '', '命盘信息获取失败，若有疑问请联系本站并寻求解决方案');
        }
      } else {
        this.dataWanZhengPage = index;
      }

    },

    /**
     * 干支高亮（区分阴阳）
     * 
     * @param {string} ganZhi 干支
     */
    gzgl(ganZhi) {

      // console.log('干支高亮 --- ' + ganZhi);

      if ('甲' === ganZhi || '寅' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.muColor + '">' + ganZhi + '</font>');
      }
      if ('丙' === ganZhi || '巳' === ganZhi || '午' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.huoColor + '">' + ganZhi + '</font>');
      }
      if ('戊' === ganZhi || '辰' === ganZhi || '戌' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.tuColor + '">' + ganZhi + '</font>');
      }
      if ('庚' === ganZhi || '申' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.jinColor + '">' + ganZhi + '</font>');
      }
      if ('壬' === ganZhi || '子' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.shuiColor + '">' + ganZhi + '</font>');
      }

      if ('乙' === ganZhi || '卯' === ganZhi) {
        if (this.ganZhiYinYang) return ganZhi.replace(ganZhi, '<font color="' + this.muColor + '"><i>' + ganZhi + '</i></font>');
        return ganZhi.replace(ganZhi, '<font color="' + this.muColor + '">' + ganZhi + '</font>')
      }
      if ('丁' === ganZhi || '午' === ganZhi) {
        if (this.ganZhiYinYang) return ganZhi.replace(ganZhi, '<font color="' + this.huoColor + '"><i>' + ganZhi + '</i></font>');
        return ganZhi.replace(ganZhi, '<font color="' + this.huoColor + '">' + ganZhi + '</font>')
      }
      if ('己' === ganZhi || '丑' === ganZhi || '未' === ganZhi) {
        if (this.ganZhiYinYang) return ganZhi.replace(ganZhi, '<font color="' + this.tuColor + '"><i>' + ganZhi + '</i></font>');
        return ganZhi.replace(ganZhi, '<font color="' + this.tuColor + '">' + ganZhi + '</font>')
      }
      if ('辛' === ganZhi || '酉' === ganZhi) {
        if (this.ganZhiYinYang) return ganZhi.replace(ganZhi, '<font color="' + this.jinColor + '"><i>' + ganZhi + '</i></font>');
        return ganZhi.replace(ganZhi, '<font color="' + this.jinColor + '">' + ganZhi + '</font>')
      }
      if ('癸' === ganZhi || '亥' === ganZhi) {
        if (this.ganZhiYinYang) return ganZhi.replace(ganZhi, '<font color="' + this.shuiColor + '"><i>' + ganZhi + '</i></font>');
        return ganZhi.replace(ganZhi, '<font color="' + this.shuiColor + '">' + ganZhi + '</font>')
      }

    },

    /**
     * 干支五行
     * 
     * @param {string} ganZhi 干支
     */
    gzwx(ganZhi) {

      if ('甲' === ganZhi || '乙' === ganZhi || '寅' === ganZhi || '卯' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.muColor + '">木</font>');
      }
      if ('丙' === ganZhi || '丁' === ganZhi || '巳' === ganZhi || '午' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.huoColor + '">火</font>');
      }
      if ('戊' === ganZhi || '己' === ganZhi || '辰' === ganZhi || '戌' === ganZhi || '丑' === ganZhi || '未' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.tuColor + '">土</font>');
      }
      if ('庚' === ganZhi || '辛' === ganZhi || '申' === ganZhi || '酉' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.jinColor + '">金</font>');
      }
      if ('壬' === ganZhi || '癸' === ganZhi || '亥' === ganZhi || '子' === ganZhi) {
        return ganZhi.replace(ganZhi, '<font color="' + this.shuiColor + '">水</font>');
      }

    },

    /**
     * 藏干高亮
     * 
     * @param {string} cangGan 天干
     */
    cggl(cangGan) {

      if ('甲' === cangGan || '乙' === cangGan || '寅' === cangGan || '卯' === cangGan) {
        return cangGan.replace(cangGan, '<font color="' + this.muColor + '">' + cangGan + '</font>');
      }
      if ('丙' === cangGan || '丁' === cangGan || '巳' === cangGan || '午' === cangGan) {
        return cangGan.replace(cangGan, '<font color="' + this.huoColor + '">' + cangGan + '</font>');
      }
      if ('戊' === cangGan || '己' === cangGan || '辰' === cangGan || '戌' === cangGan || '丑' === cangGan || '未' === cangGan) {
        return cangGan.replace(cangGan, '<font color="' + this.tuColor + '">' + cangGan + '</font>');
      }
      if ('庚' === cangGan || '辛' === cangGan || '申' === cangGan || '酉' === cangGan) {
        return cangGan.replace(cangGan, '<font color="' + this.jinColor + '">' + cangGan + '</font>');
      }
      if ('壬' === cangGan || '癸' === cangGan || '亥' === cangGan || '子' === cangGan) {
        return cangGan.replace(cangGan, '<font color="' + this.shuiColor + '">' + cangGan + '</font>');
      }

    },

    /**
     * 五行颜色
     * 
     * @param {string} wuXing 五行
     */
    wxc(wuXing) {

      if ('木' === wuXing) {
        return wuXing.replace(wuXing, '<font color=' + this.muColor + '">木</font>');
      }
      if ('火' === wuXing) {
        return wuXing.replace(wuXing, '<font color="' + this.huoColor + '">火</font>');
      }
      if ('土' === wuXing) {
        return wuXing.replace(wuXing, '<font color="' + this.tuColor + '">土</font>');
      }
      if ('金' === wuXing) {
        return wuXing.replace(wuXing, '<font color="' + this.jinColor + '">金</font>');
      }
      if ('水' === wuXing) {
        return wuXing.replace(wuXing, '<font color="' + this.shuiColor + '">水</font>');
      }

    },

    /**
     * 五行颜色2
     * 
     * @param {string} wuXing 五行（两个）
     */
    wxc2(wuXing) {

      let w1 = wuXing.substring(0, 1) // 五行1
      let w2 = wuXing.substring(1, 2) // 五行2
      let newW = '' // 新五行

      if ('木' === w1) {
        w1 = wuXing.replace(wuXing, '<font color="' + this.muColor + '">' + w1 + '</font>');
      }
      if ('火' === w1) {
        w1 = wuXing.replace(wuXing, '<font color="' + this.huoColor + '">' + w1 + '</font>');
      }
      if ('土' === w1) {
        w1 = wuXing.replace(wuXing, '<font color="' + this.tuColor + '">' + w1 + '</font>');
      }
      if ('金' === w1) {
        w1 = wuXing.replace(wuXing, '<font color="' + this.jinColor + '">' + w1 + '</font>');
      }
      if ('水' === w1) {
        w1 = wuXing.replace(wuXing, '<font color="' + this.shuiColor + '">' + w1 + '</font>');
      }

      if ('木' === w2) {
        newW = w1 + wuXing.replace(wuXing, '<font color="' + this.muColor + '">' + w2 + '</font>');
      }
      if ('火' === w2) {
        newW = w1 + wuXing.replace(wuXing, '<font color="' + this.huoColor + '">' + w2 + '</font>');
      }
      if ('土' === w2) {
        newW = w1 + wuXing.replace(wuXing, '<font color="' + this.tuColor + '">' + w2 + '</font>');
      }
      if ('金' === w2) {
        newW = w1 + wuXing.replace(wuXing, '<font color="' + this.jinColor + '">' + w2 + '</font>');
      }
      if ('水' === w2) {
        newW = w1 + wuXing.replace(wuXing, '<font color="' + this.shuiColor + '"">' + w2 + '</font>');
      }

      return newW;

    },

    /**
     * 五行旺衰颜色
     * 
     * @param {string} wuXing 五行
     */
    wxwsc(wuXing) {

      let l = wuXing.substring(0, 1);

      if ('木' === l) {
        return wuXing.replace(wuXing, '<font color="' + this.muColor + '">' + wuXing + '</font>');
      }
      if ('火' === l) {
        return wuXing.replace(wuXing, '<font color="' + this.huoColor + '">' + wuXing + '</font>');
      }
      if ('土' === l) {
        return wuXing.replace(wuXing, '<font color="' + this.tuColor + '">' + wuXing + '</font>');
      }
      if ('金' === l) {
        return wuXing.replace(wuXing, '<font color="' + this.jinColor + '">' + wuXing + '</font>');
      }
      if ('水' === l) {
        return wuXing.replace(wuXing, '<font color="' + this.shuiColor + '">' + wuXing + '</font>');
      }

    },

    /**
     * 八字颜色
     * 
     * @param {string} ganZhi 干支
     */
    bzc(ganZhi) {

      let gan = ganZhi.substring(0, 1); // 天干
      let zhi = ganZhi.substring(1, 2); // 地支
      let newGanZhi = ''; // 新干支

      if ('甲' === gan || '乙' === gan) {
        gan = ganZhi.replace(ganZhi, '<font color="' + this.muColor + '">' + gan + '</font>');
      }
      if ('丙' === gan || '丁' === gan) {
        gan = ganZhi.replace(ganZhi, '<font color="' + this.huoColor + '">' + gan + '</font>');
      }
      if ('戊' === gan || '己' === gan) {
        gan = ganZhi.replace(ganZhi, '<font color="' + this.tuColor + '">' + gan + '</font>');
      }
      if ('庚' === gan || '辛' === gan) {
        gan = ganZhi.replace(ganZhi, '<font color="' + this.jinColor + '">' + gan + '</font>');
      }
      if ('壬' === gan || '癸' === gan) {
        gan = ganZhi.replace(ganZhi, '<font color="' + this.shuiColor + '">' + gan + '</font>');
      }

      if ('寅' === zhi || '卯' === zhi) {
        newGanZhi = gan + ganZhi.replace(ganZhi, '<font color="' + this.muColor + '">' + zhi + '</font>');
      }
      if ('巳' === zhi || '午' === zhi) {
        newGanZhi = gan + ganZhi.replace(ganZhi, '<font color="' + this.huoColor + '">' + zhi + '</font>');
      }
      if ('辰' === zhi || '戌' === zhi || '丑' === zhi || '未' === zhi) {
        newGanZhi = gan + ganZhi.replace(ganZhi, '<font color="' + this.tuColor + '">' + zhi + '</font>');
      }
      if ('申' === zhi || '酉' === zhi) {
        newGanZhi = gan + ganZhi.replace(ganZhi, '<font color="' + this.jinColor + '">' + zhi + '</font>');
      }
      if ('亥' === zhi || '子' === zhi) {
        newGanZhi = gan + ganZhi.replace(ganZhi, '<font color="' + this.shuiColor + '">' + zhi + '</font>');
      }

      return newGanZhi;

    },

    /**
     * 八字颜色2
     * 
     * @param {string} ganZhi 天干或地支
     */
    bzc2(ganOrZhi) {

      let newGanOrZhi = ''; // 新干支

      if ('甲' === ganOrZhi || '乙' === ganOrZhi || '寅' === ganOrZhi || '卯' === ganOrZhi) {
        newGanOrZhi = ganOrZhi.replace(ganOrZhi, '<font color="' + this.muColor + '">' + ganOrZhi + '</font>');
      }
      if ('丙' === ganOrZhi || '丁' === ganOrZhi || '巳' === ganOrZhi || '午' === ganOrZhi) {
        newGanOrZhi = ganOrZhi.replace(ganOrZhi, '<font color="' + this.huoColor + '">' + ganOrZhi + '</font>');
      }
      if ('戊' === ganOrZhi || '己' === ganOrZhi || '辰' === ganOrZhi || '戌' === ganOrZhi || '丑' === ganOrZhi || '未' === ganOrZhi) {
        newGanOrZhi = ganOrZhi.replace(ganOrZhi, '<font color="' + this.tuColor + '">' + ganOrZhi + '</font>');
      }
      if ('庚' === ganOrZhi || '辛' === ganOrZhi || '申' === ganOrZhi || '酉' === ganOrZhi) {
        newGanOrZhi = ganOrZhi.replace(ganOrZhi, '<font color="' + this.jinColor + '">' + ganOrZhi + '</font>');
      }
      if ('壬' === ganOrZhi || '癸' === ganOrZhi || '亥' === ganOrZhi || '子' === ganOrZhi) {
        newGanOrZhi = ganOrZhi.replace(ganOrZhi, '<font color="' + this.shuiColor + '">' + ganOrZhi + '</font>');
      }

      return newGanOrZhi;

    },

    /**
     * 切换五行木颜色
     * 
     * @param {string} value 颜色值
     */
    switchMuColor(value) {
      this.muColor = value;
    },

    /**
     * 切换五行火颜色
     * 
     * @param {string} value 颜色值
     */
    switchHuoColor(value) {
      this.huoColor = value;
    },

    /**
     * 切换五行土颜色
     * 
     * @param {string} value 颜色值
     */
    switchTuColor(value) {
      this.tuColor = value;
    },

    /**
     * 切换五行金颜色
     * 
     * @param {string} value 颜色值
     */
    switchJinColor(value) {
      this.jinColor = value;
    },

    /**
     * 切换五行水颜色
     * 
     * @param {string} value 颜色值
     */
    switchShuiColor(value) {
      this.shuiColor = value;
    },

    /**
     * 重置颜色
     */
    resettingColor() {

      this.muColor = '#00ad00'; // 五行木颜色
      this.huoColor = '#d40000'; // 五行火颜色
      this.tuColor = '#b16400'; // 五行土颜色
      this.jinColor = '#efa800'; // 五行金颜色
      this.shuiColor = '#2e83f6'; // 五行水颜色

    },

    //****************************************************************************************

    /**
     * 占事功能提示
     */
    occupyPrompt() {

      this.notification('info', 1500, '', '该功能正在完善中，暂未提供相关解读');

    },

    /**
     * 消息提示（顶部居中弹出）
     * 
     * @param {number} duration 显示时间（单位：毫秒）
     * @param {boolean} showClose 是否可关闭（true:是。false:否）
     * @param {string} type 消息类型（success、warning、error）
     * @param {string} message 提示内容
     */
    elMessage(duration, showClose, type, message) {
      ElMessage({
        duration: duration,
        showClose: showClose,
        type: type,
        message: message,
        plain: true
      })
    },

    /**
     * 通知提示（右上角弹出）
     * 
     * @param {string} type 消息类型（success、warning、error）
     * @param {number} duration 自动关闭延迟，0为不关闭（单位：毫秒）
     * @param {string} title 标题
     * @param {string} message 提示内容
     */
    notification(type, duration, title, message) {
      ElNotification({
        type: type,
        title: title,
        message: message,
        duration: duration,
        position: 'top-right',
        dangerouslyUseHTMLString: true
      })
    }

  }
}
